JavaScript模块架构：设计模式实现

            // myModule.js
module.exports = {
  myFunction: function() {
    console.log('Hello from myModule!');
  }
};

// app.js
const myModule = require('./myModule');
myModule.myFunction();

            

              
                Copy
              
            
          

            
// myModule.js (using RequireJS syntax)
define(function() {
  return {
    myFunction: function() {
      console.log('Hello from myModule (AMD)!');
    }
  };
});

// app.js (using RequireJS syntax)
require(['./myModule'], function(myModule) {
  myModule.myFunction();
});

            

              
                Copy
              
            
          

            
// myModule.js
export function myFunction() {
  console.log('Hello from myModule (ESM)!');
}

// app.js
import { myFunction } from './myModule.js';
myFunction();

            

              
                Copy
              
            
          

            
// Using an immediately invoked function expression (IIFE) to create the singleton
const singleton = (function() {
  let instance;

  function createInstance() {
    const object = new Object({ name: 'Singleton Instance' });
    return object;
  }

  return {
    getInstance: function() {
      if (!instance) {
        instance = createInstance();
      }
      return instance;
    },
  };
})();

// Usage
const instance1 = singleton.getInstance();
const instance2 = singleton.getInstance();

console.log(instance1 === instance2); // Output: true
console.log(instance1.name); // Output: Singleton Instance

            

              
                Copy
              
            
          

            
// Factory function
function createCar(type, options) {
  switch (type) {
    case 'sedan':
      return new Sedan(options);
    case 'suv':
      return new SUV(options);
    default:
      return null;
  }
}

// Car classes (implementation)
class Sedan {
  constructor(options) {
    this.type = 'Sedan';
    this.color = options.color || 'white';
    this.model = options.model || 'Unknown';
  }
  getDescription() {
    return `This is a ${this.color} ${this.model} Sedan.`
  }
}

class SUV {
  constructor(options) {
    this.type = 'SUV';
    this.color = options.color || 'black';
    this.model = options.model || 'Unknown';
  }
  getDescription() {
    return `This is a ${this.color} ${this.model} SUV.`
  }
}

// Usage
const mySedan = createCar('sedan', { color: 'blue', model: 'Camry' });
const mySUV = createCar('suv', { model: 'Explorer' });

console.log(mySedan.getDescription()); // Output: This is a blue Camry Sedan.
console.log(mySUV.getDescription()); // Output: This is a black Explorer SUV.

            

              
                Copy
              
            
          

            
class Subject {
  constructor() {
    this.observers = [];
  }

  subscribe(observer) {
    this.observers.push(observer);
  }

  unsubscribe(observer) {
    this.observers = this.observers.filter(obs => obs !== observer);
  }

  notify(data) {
    this.observers.forEach(observer => observer.update(data));
  }
}

class Observer {
  constructor(name) {
    this.name = name;
  }

  update(data) {
    console.log(`${this.name} received: ${data}`);
  }
}

// Usage
const subject = new Subject();
const observer1 = new Observer('Observer 1');
const observer2 = new Observer('Observer 2');

subject.subscribe(observer1);
subject.subscribe(observer2);

subject.notify('Hello, observers!'); // Observer 1 received: Hello, observers!  Observer 2 received: Hello, observers!

subject.unsubscribe(observer1);
subject.notify('Another update!'); // Observer 2 received: Another update!

            

              
                Copy
              
            
          

            
const myModule = (function() {
  // Private variables and functions
  let privateVariable = 'Hello';

  function privateFunction() {
    console.log('This is a private function.');
  }

  // Public interface
  return {
    publicMethod: function() {
      console.log(privateVariable);
      privateFunction();
    },
    publicVariable: 'World'
  };
})();

// Usage
myModule.publicMethod(); // Output: Hello  This is a private function.
console.log(myModule.publicVariable); // Output: World
// console.log(myModule.privateVariable); // Error: privateVariable is not defined (accessing private variables is not allowed)

            

              
                Copy
              
            
          

            
const revealingModule = (function() {
  let privateVariable = 'Secret Message';

  function privateFunction() {
    console.log('Inside privateFunction');
  }

  function publicGet() {
    return privateVariable;
  }

  function publicSet(value) {
    privateVariable = value;
  }

  // Reveal public members
  return {
    get: publicGet,
    set: publicSet,
    // You can also reveal privateFunction (but usually it is hidden)
    // show: privateFunction
  };
})();

// Usage
console.log(revealingModule.get()); // Output: Secret Message
revealingModule.set('New Secret');
console.log(revealingModule.get()); // Output: New Secret
// revealingModule.privateFunction(); // Error: revealingModule.privateFunction is not a function

            

              
                Copy
              
            
          

            
// Component interface (base object)
class Pizza {
  constructor() {
    this.description = 'Plain Pizza';
  }

  getDescription() {
    return this.description;
  }

  getCost() {
    return 10;
  }
}

// Decorator abstract class
class PizzaDecorator extends Pizza {
  constructor(pizza) {
    super();
    this.pizza = pizza;
  }

  getDescription() {
    return this.pizza.getDescription();
  }

  getCost() {
    return this.pizza.getCost();
  }
}

// Concrete Decorators
class CheeseDecorator extends PizzaDecorator {
  constructor(pizza) {
    super(pizza);
    this.description = 'Cheese Pizza';
  }

  getDescription() {
    return `${this.pizza.getDescription()}, Cheese`;
  }

  getCost() {
    return this.pizza.getCost() + 2;
  }
}

class PepperoniDecorator extends PizzaDecorator {
  constructor(pizza) {
    super(pizza);
    this.description = 'Pepperoni Pizza';
  }

  getDescription() {
    return `${this.pizza.getDescription()}, Pepperoni`;
  }

  getCost() {
    return this.pizza.getCost() + 3;
  }
}

// Usage
let pizza = new Pizza();
pizza = new CheeseDecorator(pizza);
pizza = new PepperoniDecorator(pizza);

console.log(pizza.getDescription()); // Output: Plain Pizza, Cheese, Pepperoni
console.log(pizza.getCost()); // Output: 15

            

              
                Copy